

import (Combatd) in "adm/daemons/Combatd";
//属性
var attr=({});
//临时属性 下线丢失
var tempAttr=({});

number test(){
}


number save(){

    println("有子类调用了我");
}


map entityData(){
    return this.attr;
}

number setName(string name,string* ids){
    set("name",name);
    set("ids",ids);
    return 1;
}

string idsStr(){
    return implode(query("ids"),",");
}

//所有的对象 都是多个ID，默认取第一个ID
string id(){
    //默认取第一个
    return query("ids")[0];
}

string ids(){
    return query("ids");
}


//战斗中的敌人
string* killers(){
  //初始化一下
  if( !arrayp(  query("killers") ) ) set("killers",([]));
  return query("killers");
}

object* enemy(){

  if( !arrayp(  query("enemy") ) )  set("enemy",([]));
  return query("enemy");

}

object selectOpponent(){
    if( sizeof(enemy()) > 0 ){
        return enemy()[0];
    }else{
        return 0;
    }


}

number killOb(object ob){
    string* ks = killers();
    string obId = ob.id();
    if( !(obId in ks)  ){
        query("killers")+= ob.id();
        enemy()+=ob;
        tellObject(ob, fmt("看起来%s想杀死你!",query("name")));
        ob.killOb(this);
    }
}

number removeKiller(object ob){

      query("killers")-= ob.id();
      enemy()-=ob;

      println(fmt("killers size %s,enemy size %s",sizeof(query("killers")),sizeof(enemy())));

}

number attack(){

    object *ks;
    if( !objectp(this) ){
        println("已销毁咯...");
        return 1;
    }
    if( sizeof( (ks = killers()) ) > 0 ){
          println(fmt("ks size %s",sizeof(ks)));
          println(query("name")+" "+"attack!!!");
          object v = selectOpponent();
          if( !objectp(this) || !objectp(v) ) return 0;
          Combatd::fight(this,selectOpponent());
    }

}



//重量
number setWeight(number wgt){
    set("weight",wgt);
}
number set( string path, var value) {




    var parts = explode(path, "/");
    var currentMap = this.attr;

    for (number i = 0; i < sizeof(parts) - 1; i++) {
        var key = parts[i];
        var nextMap = currentMap[key];

        if (!nextMap) {
            // 创建新映射节点
            nextMap = ({});
            currentMap[key] = nextMap;
        } else if (!mapp(nextMap)) {
            // 关键修改：直接替换为新映射（丢弃原值）
            nextMap = ({});
            currentMap[key] = nextMap;
        }

        currentMap = nextMap;
    }

    var idx = parts[sizeof(parts) - 1];
    currentMap[idx] = value;
    return 1;
}

// number set( string path, var value) {
//
//    var parts = explode(path, "/");
//    var currentMap = this.attr;
//    for (number i = 0; i < sizeof(parts) - 1; i++) {
//        // 需要检查是否是 map，string 为空也是 false
//        var nextMap = currentMap[parts[i]];
//        if (!nextMap) {
//            nextMap = ({});
//            currentMap[parts[i]] = nextMap;
//        }
//        currentMap = nextMap;
//    }
//
//    var idx = parts[sizeof(parts) - 1];
//    if( !mapp(currentMap) ){
//        currentMap = ({});
//    }
//    currentMap[idx] = value;
//
//
//}


number add( string path, var value) {
    var parts = explode(path, "/");
    var currentMap = this.attr;

    // 遍历路径创建嵌套结构（与set方法相同）
    for (number i = 0; i < sizeof(parts) - 1; i++) {
        var key = parts[i];
        var nextMap = currentMap[key];

        if (!nextMap) {
            nextMap = ({});
            currentMap[key] = nextMap;
        } else if (!mapp(nextMap)) {
            // 关键修复：与set方法保持一致，将非映射类型转换为映射
            currentMap[key] = ({ key : nextMap });
            nextMap = currentMap[key];
        }

        currentMap = nextMap;
    }

    var idx = parts[sizeof(parts) - 1];
    var currentValue = currentMap[idx];


    if( !currentValue ){
         currentMap[idx] = value;
    }else if( numberp(currentValue) ){
        println( fmt("numberp %s += %s",currentValue,value)  );



        currentMap[idx] += value;
    }


    return 1; // 返回成功标志
}

 number  query(string path) {
    var parts = explode(path, "/");
      var currentMap = this.attr;

      for (number i = 0; i < sizeof(parts); i++) {
          var key = parts[i];
          var nextValue = currentMap[key];

          if (!nextValue) {
              return 0;  // 路径不存在，返回undefined而非0
          }

          // 如果不是最后一个元素，继续深入
          if (i < sizeof(parts) - 1) {
              if (!mapp(nextValue)) {
                  return 0;  // 路径不完整（非映射类型）
              }
              currentMap = nextValue;  // 继续遍历下一层
          } else {
              return nextValue;  // 返回最终值
          }
      }

      return 0;  // 如果路径为空
 }
number delete(string path) {
    var parts = explode(path, "/");
    var currentMap = this.attr;
    var parentMap;
    var parentKey;  // 重命名为 parentKey 更清晰

    // 遍历到倒数第二个节点，保存父节点引用
    for (number i = 0; i < sizeof(parts) - 1; i++) {
        var key = parts[i];
        var nextMap = currentMap[key];

        if (!nextMap) {
            return 0;  // 路径不存在，删除失败
        }

        if (!mapp(nextMap)) {
            return 0;  // 路径不完整（非映射类型）
        }

        parentMap = currentMap;
        parentKey = key;  // 保存父映射的键名
        currentMap = nextMap;
    }

    // 获取最后一个键
    var lastPart = parts[sizeof(parts) - 1];

    // 检查最后一个键是否存在
    if (!currentMap[lastPart]) {
        return 0;  // 目标键不存在
    }

    // 删除目标键
    mapDelete(currentMap, lastPart);

    // 如果当前映射为空，从父映射中删除
    if (sizeof(currentMap) == 0 && parentMap) {
        mapDelete(parentMap, parentKey);  // 使用 parentKey 删除空映射
    }

    return 1;  // 删除成功
}
 number setTemp( var path, var value) {


    var parts = explode(path, "/");
    var currentMap = this.attr;

    for (number i = 0; i < sizeof(parts) - 1; i++) {
        var key = parts[i];
        var nextMap = currentMap[key];

        if (!nextMap) {
            // 创建新映射节点
            nextMap = ({});
            currentMap[key] = nextMap;
        } else if (!mapp(nextMap)) {
            // 关键修改：直接替换为新映射（丢弃原值）
            nextMap = ({});
            currentMap[key] = nextMap;
        }

        currentMap = nextMap;
    }

    var idx = parts[sizeof(parts) - 1];
    currentMap[idx] = value;
    return 1;


}


 number  queryTemp(string path) {
   var parts = explode(path, "/");
   var currentMap = this.attr;

   for (number i = 0; i < sizeof(parts); i++) {
       var key = parts[i];
       var nextValue = currentMap[key];

       if (!nextValue) {
           return 0;  // 路径不存在，返回undefined而非0
       }

       // 如果不是最后一个元素，继续深入
       if (i < sizeof(parts) - 1) {
           if (!mapp(nextValue)) {
               return 0;  // 路径不完整（非映射类型）
           }
           currentMap = nextValue;  // 继续遍历下一层
       } else {
           return nextValue;  // 返回最终值
       }
   }

   return 0;  // 如果路径为空
 }


number addTemp( string path, var value) {
    var parts = explode(path, "/");
    var currentMap = this.attr;

    // 遍历路径创建嵌套结构（与set方法相同）
    for (number i = 0; i < sizeof(parts) - 1; i++) {
        var key = parts[i];
        var nextMap = currentMap[key];

        if (!nextMap) {
            nextMap = ({});
            currentMap[key] = nextMap;
        } else if (!mapp(nextMap)) {
            // 关键修复：与set方法保持一致，将非映射类型转换为映射
            currentMap[key] = ({ key : nextMap });
            nextMap = currentMap[key];
        }

        currentMap = nextMap;
    }

    var idx = parts[sizeof(parts) - 1];
    var currentValue = currentMap[idx];


    if( !currentValue ){
         currentMap[idx] = value;
    }else if( numberp(currentValue) ){
        println( fmt("numberp %s += %s",currentValue,value)  );



        currentMap[idx] += value;
    }


    return 1; // 返回成功标志
}

 number move(var dest){

    moveObject(this,dest);
 }
//如果子类重写die 且需要销毁自身，需要super.die();
 number die(){

    //通知我所在的环境
    object env;
    if( (env = environment(this)) ){
        env.removeInventory( this );
    }
    //通知我的所有内容物
    foreach( ob in allInventory(this)){
        if( objectp(ob) ){
            ob.moveOrDestruct();
        }else{
            //这儿ob应该是被销毁的了，要注意处理
        }
    }
   //执行销毁自身
   doDestruct();
 }

 number doDestruct(){
    destruct(this);
 }

//移除指定的内容物
number removeInventory(object ob){
    println(fmt("%s 删除内容物 %s",fileName(this),fileName(ob)));
    rmInventory(this,ob);

    if( this.isRoom ){

        tellEnv(this,fmt("%s 离开了",ob.query("name")));
    }

}

//子类可以直接重写
number moveOrDestruct(){


}




